In many code development scenarios developers seek to verify that code adheres to rules prescribed for interaction of the code with other components. An example of such a scenario is in the context of driver code that may call into and/or be called through various operating system components (e.g., tools, functions, interfaces, services, and so forth) to take advantage of operating system features and/or cause operation of a corresponding device. More generally, verification techniques may be applied to client applications that take advantage of functionality provided by a central module to extend the central module. Verifications may be performed to detect and address instances in which code misbehaves in some manner or causes a computing system to freeze/crash (e.g., detect “bugs”).
Verification may involve analysis that is performed to verify compliance of a complete code project against a set of rules, such as by analyzing a driver as a whole. Traditionally, verification rules are individually defined and tests for compliance with the rules must be manually coded into the verification system. Thus, implementing rules for complex code projects may be time consuming and resource intensive. Further, it is difficult to modify the rules or add new rules due to overhead associated with making changes to the verification system. Moreover, distinct set of rules that may have different forms are traditionally authored by different people for different types of verifications (e.g., static vs. run-time) and/or different types of client code. This approach results in inconsistent rules that may be difficult for a developer to understand and redundant work to create and maintain multiple distinct set of rules. Thus, traditional verification techniques may be inefficient and/or inadequate for some types of software systems and corresponding testing scenarios.